package jsqlite.JDBC2z;

import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.BatchUpdateException;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.NClob;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.sql.SQLXML;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Map;
import jsqlite.Database;
import jsqlite.StringEncoder;

/* loaded from: classes2.dex */
public class JDBCPreparedStatement extends JDBCStatement implements PreparedStatement {
    private static final boolean nullrepl;
    private String[] args;
    private ArrayList<BatchArg> batch;
    private boolean[] blobs;
    private String sql;

    static {
        nullrepl = Database.version().compareTo("2.5.0") < 0;
    }

    public JDBCPreparedStatement(JDBCConnection jDBCConnection, String str) {
        super(jDBCConnection);
        this.args = null;
        this.blobs = null;
        this.batch = null;
        this.sql = fixup(str);
    }

    private String fixup(String str) {
        StringBuffer stringBuffer = new StringBuffer();
        int i = 0;
        boolean z = false;
        int i2 = 0;
        while (i < str.length()) {
            char charAt = str.charAt(i);
            if (charAt == '\'') {
                if (z) {
                    int i3 = i + 1;
                    char charAt2 = i3 < str.length() ? str.charAt(i3) : (char) 0;
                    if (charAt2 == '\'') {
                        stringBuffer.append(charAt);
                        stringBuffer.append(charAt2);
                        i = i3;
                    } else {
                        stringBuffer.append(charAt);
                        z = false;
                    }
                } else {
                    stringBuffer.append(charAt);
                    z = true;
                }
            } else if (charAt == '?') {
                if (z) {
                    stringBuffer.append(charAt);
                } else {
                    i2++;
                    stringBuffer.append(nullrepl ? "'%q'" : "%Q");
                }
            } else if (charAt == ';') {
                if (!z) {
                    break;
                }
                stringBuffer.append(charAt);
            } else if (charAt == '%') {
                stringBuffer.append("%%");
            } else {
                stringBuffer.append(charAt);
            }
            i++;
        }
        this.args = new String[i2];
        this.blobs = new boolean[i2];
        try {
            clearParameters();
        } catch (SQLException unused) {
        }
        return stringBuffer.toString();
    }

    private String fixup2(String str) {
        if (this.conn.db.is3()) {
            StringBuffer stringBuffer = new StringBuffer();
            int i = -1;
            int i2 = 0;
            while (i2 < str.length()) {
                char charAt = str.charAt(i2);
                if (charAt == '%') {
                    stringBuffer.append(charAt);
                    i2++;
                    charAt = str.charAt(i2);
                    if (charAt == 'Q') {
                        i++;
                        if (this.blobs[i]) {
                            charAt = 's';
                        }
                    }
                }
                stringBuffer.append(charAt);
                i2++;
            }
            return stringBuffer.toString();
        }
        return str;
    }

    @Override // java.sql.PreparedStatement
    public ResultSet executeQuery() throws SQLException {
        return executeQuery(fixup2(this.sql), this.args, false);
    }

    @Override // java.sql.PreparedStatement
    public int executeUpdate() throws SQLException {
        executeQuery(fixup2(this.sql), this.args, true);
        return this.updcnt;
    }

    @Override // java.sql.PreparedStatement
    public void setNull(int i, int i2) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                int i3 = i - 1;
                strArr[i3] = nullrepl ? "" : null;
                this.blobs[i3] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setBoolean(int i, boolean z) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                int i2 = i - 1;
                strArr[i2] = z ? "1" : "0";
                this.blobs[i2] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setByte(int i, byte b) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                int i2 = i - 1;
                StringBuilder sb = new StringBuilder();
                sb.append((int) b);
                strArr[i2] = sb.toString();
                this.blobs[i2] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setShort(int i, short s) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                int i2 = i - 1;
                StringBuilder sb = new StringBuilder();
                sb.append((int) s);
                strArr[i2] = sb.toString();
                this.blobs[i2] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setInt(int i, int i2) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                int i3 = i - 1;
                StringBuilder sb = new StringBuilder();
                sb.append(i2);
                strArr[i3] = sb.toString();
                this.blobs[i3] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setLong(int i, long j) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                int i2 = i - 1;
                StringBuilder sb = new StringBuilder();
                sb.append(j);
                strArr[i2] = sb.toString();
                this.blobs[i2] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setFloat(int i, float f) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                int i2 = i - 1;
                StringBuilder sb = new StringBuilder();
                sb.append(f);
                strArr[i2] = sb.toString();
                this.blobs[i2] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setDouble(int i, double d) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                int i2 = i - 1;
                StringBuilder sb = new StringBuilder();
                sb.append(d);
                strArr[i2] = sb.toString();
                this.blobs[i2] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setBigDecimal(int i, BigDecimal bigDecimal) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                if (bigDecimal == null) {
                    strArr[i - 1] = nullrepl ? "" : null;
                } else {
                    StringBuilder sb = new StringBuilder();
                    sb.append(bigDecimal);
                    strArr[i - 1] = sb.toString();
                }
                this.blobs[i - 1] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setString(int i, String str) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                if (str == null) {
                    strArr[i - 1] = nullrepl ? "" : null;
                } else {
                    strArr[i - 1] = str;
                }
                this.blobs[i - 1] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setBytes(int i, byte[] bArr) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                int i2 = i - 1;
                this.blobs[i2] = false;
                if (bArr == null) {
                    strArr[i2] = nullrepl ? "" : null;
                    return;
                } else if (this.conn.db.is3()) {
                    this.args[i2] = StringEncoder.encodeX(bArr);
                    this.blobs[i2] = true;
                    return;
                } else {
                    this.args[i2] = StringEncoder.encode(bArr);
                    return;
                }
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setDate(int i, Date date) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                if (date == null) {
                    strArr[i - 1] = nullrepl ? "" : null;
                } else if (this.conn.useJulian) {
                    this.args[i - 1] = Double.toString(Database.julian_from_long(date.getTime()));
                } else {
                    this.args[i - 1] = date.toString();
                }
                this.blobs[i - 1] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setTime(int i, Time time) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                if (time == null) {
                    strArr[i - 1] = nullrepl ? "" : null;
                } else if (this.conn.useJulian) {
                    this.args[i - 1] = Double.toString(Database.julian_from_long(time.getTime()));
                } else {
                    this.args[i - 1] = time.toString();
                }
                this.blobs[i - 1] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setTimestamp(int i, Timestamp timestamp) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                if (timestamp == null) {
                    strArr[i - 1] = nullrepl ? "" : null;
                } else if (this.conn.useJulian) {
                    this.args[i - 1] = Double.toString(Database.julian_from_long(timestamp.getTime()));
                } else {
                    this.args[i - 1] = timestamp.toString();
                }
                this.blobs[i - 1] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setAsciiStream(int i, InputStream inputStream, int i2) throws SQLException {
        throw new SQLException("not supported");
    }

    @Override // java.sql.PreparedStatement
    @Deprecated
    public void setUnicodeStream(int i, InputStream inputStream, int i2) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setBinaryStream(int i, InputStream inputStream, int i2) throws SQLException {
        try {
            byte[] bArr = new byte[i2];
            inputStream.read(bArr, 0, i2);
            setBytes(i, bArr);
        } catch (IOException unused) {
            throw new SQLException("I/O failed");
        }
    }

    @Override // java.sql.PreparedStatement
    public void clearParameters() throws SQLException {
        int i = 0;
        while (true) {
            String[] strArr = this.args;
            if (i >= strArr.length) {
                return;
            }
            strArr[i] = nullrepl ? "" : null;
            this.blobs[i] = false;
            i++;
        }
    }

    @Override // java.sql.PreparedStatement
    public void setObject(int i, Object obj, int i2, int i3) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                if (obj == null) {
                    strArr[i - 1] = nullrepl ? "" : null;
                } else if (obj instanceof byte[]) {
                    byte[] bArr = (byte[]) obj;
                    if (this.conn.db.is3()) {
                        int i4 = i - 1;
                        this.args[i4] = StringEncoder.encodeX(bArr);
                        this.blobs[i4] = true;
                        return;
                    }
                    this.args[i - 1] = StringEncoder.encode(bArr);
                } else {
                    strArr[i - 1] = obj.toString();
                }
                this.blobs[i - 1] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setObject(int i, Object obj, int i2) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                if (obj == null) {
                    strArr[i - 1] = nullrepl ? "" : null;
                } else if (obj instanceof byte[]) {
                    byte[] bArr = (byte[]) obj;
                    if (this.conn.db.is3()) {
                        int i3 = i - 1;
                        this.args[i3] = StringEncoder.encodeX(bArr);
                        this.blobs[i3] = true;
                        return;
                    }
                    this.args[i - 1] = StringEncoder.encode(bArr);
                } else {
                    strArr[i - 1] = obj.toString();
                }
                this.blobs[i - 1] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public void setObject(int i, Object obj) throws SQLException {
        if (i >= 1) {
            String[] strArr = this.args;
            if (i <= strArr.length) {
                if (obj == null) {
                    strArr[i - 1] = nullrepl ? "" : null;
                } else if (obj instanceof byte[]) {
                    byte[] bArr = (byte[]) obj;
                    if (this.conn.db.is3()) {
                        int i2 = i - 1;
                        this.args[i2] = StringEncoder.encodeX(bArr);
                        this.blobs[i2] = true;
                        return;
                    }
                    this.args[i - 1] = StringEncoder.encode(bArr);
                } else {
                    strArr[i - 1] = obj.toString();
                }
                this.blobs[i - 1] = false;
                return;
            }
        }
        throw new SQLException("bad parameter index");
    }

    @Override // java.sql.PreparedStatement
    public boolean execute() throws SQLException {
        return executeQuery(fixup2(this.sql), this.args, false) != null;
    }

    @Override // java.sql.PreparedStatement
    public void addBatch() throws SQLException {
        if (this.batch == null) {
            this.batch = new ArrayList<>(this.args.length);
        }
        int i = 0;
        while (true) {
            String[] strArr = this.args;
            if (i >= strArr.length) {
                return;
            }
            this.batch.add(new BatchArg(strArr[i], this.blobs[i]));
            i++;
        }
    }

    @Override // jsqlite.JDBC2z.JDBCStatement, java.sql.Statement
    public int[] executeBatch() throws SQLException {
        ArrayList<BatchArg> arrayList = this.batch;
        if (arrayList == null) {
            return new int[0];
        }
        int size = arrayList.size() / this.args.length;
        int[] iArr = new int[size];
        for (int i = 0; i < size; i++) {
            iArr[i] = -3;
        }
        int i2 = 0;
        int i3 = 0;
        for (int i4 = 0; i4 < size; i4++) {
            int i5 = 0;
            while (i5 < this.args.length) {
                int i6 = i2 + 1;
                BatchArg batchArg = this.batch.get(i2);
                this.args[i5] = batchArg.arg;
                this.blobs[i5] = batchArg.blob;
                i5++;
                i2 = i6;
            }
            try {
                iArr[i4] = executeUpdate();
            } catch (SQLException unused) {
                i3++;
            }
        }
        if (i3 <= 0) {
            return iArr;
        }
        throw new BatchUpdateException("batch failed", iArr);
    }

    @Override // jsqlite.JDBC2z.JDBCStatement, java.sql.Statement
    public void clearBatch() throws SQLException {
        ArrayList<BatchArg> arrayList = this.batch;
        if (arrayList != null) {
            arrayList.clear();
            this.batch = null;
        }
    }

    @Override // jsqlite.JDBC2z.JDBCStatement, java.sql.Statement, java.lang.AutoCloseable
    public void close() throws SQLException {
        clearBatch();
        super.close();
    }

    @Override // java.sql.PreparedStatement
    public void setCharacterStream(int i, Reader reader, int i2) throws SQLException {
        try {
            char[] cArr = new char[i2];
            reader.read(cArr);
            setString(i, new String(cArr));
        } catch (IOException unused) {
            throw new SQLException("I/O failed");
        }
    }

    @Override // java.sql.PreparedStatement
    public void setRef(int i, Ref ref) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setBlob(int i, Blob blob) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setClob(int i, Clob clob) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setArray(int i, Array array) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public ResultSetMetaData getMetaData() throws SQLException {
        return this.rs.getMetaData();
    }

    @Override // java.sql.PreparedStatement
    public void setDate(int i, Date date, Calendar calendar) throws SQLException {
        setDate(i, date);
    }

    @Override // java.sql.PreparedStatement
    public void setTime(int i, Time time, Calendar calendar) throws SQLException {
        setTime(i, time);
    }

    @Override // java.sql.PreparedStatement
    public void setTimestamp(int i, Timestamp timestamp, Calendar calendar) throws SQLException {
        setTimestamp(i, timestamp);
    }

    @Override // java.sql.PreparedStatement
    public void setNull(int i, int i2, String str) throws SQLException {
        setNull(i, i2);
    }

    @Override // java.sql.PreparedStatement
    public ParameterMetaData getParameterMetaData() throws SQLException {
        throw new SQLException("not supported");
    }

    public void registerOutputParameter(String str, int i) throws SQLException {
        throw new SQLException("not supported");
    }

    public void registerOutputParameter(String str, int i, int i2) throws SQLException {
        throw new SQLException("not supported");
    }

    public void registerOutputParameter(String str, int i, String str2) throws SQLException {
        throw new SQLException("not supported");
    }

    public URL getURL(int i) throws SQLException {
        throw new SQLException("not supported");
    }

    @Override // java.sql.PreparedStatement
    public void setURL(int i, URL url) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setNull(String str, int i) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setBoolean(String str, boolean z) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setByte(String str, byte b) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setShort(String str, short s) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setInt(String str, int i) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setLong(String str, long j) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setFloat(String str, float f) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setDouble(String str, double d) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setBigDecimal(String str, BigDecimal bigDecimal) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setString(String str, String str2) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setBytes(String str, byte[] bArr) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setDate(String str, Date date) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setTime(String str, Time time) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setTimestamp(String str, Timestamp timestamp) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setAsciiStream(String str, InputStream inputStream, int i) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setBinaryStream(String str, InputStream inputStream, int i) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setObject(String str, Object obj, int i, int i2) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setObject(String str, Object obj, int i) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setObject(String str, Object obj) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setCharacterStream(String str, Reader reader, int i) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setDate(String str, Date date, Calendar calendar) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setTime(String str, Time time, Calendar calendar) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setTimestamp(String str, Timestamp timestamp, Calendar calendar) throws SQLException {
        throw new SQLException("not supported");
    }

    public void setNull(String str, int i, String str2) throws SQLException {
        throw new SQLException("not supported");
    }

    public String getString(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public boolean getBoolean(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public byte getByte(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public short getShort(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public int getInt(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public long getLong(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public float getFloat(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public double getDouble(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public byte[] getBytes(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public Date getDate(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public Time getTime(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public Timestamp getTimestamp(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public Object getObject(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public Object getObject(int i) throws SQLException {
        throw new SQLException("not supported");
    }

    public BigDecimal getBigDecimal(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public Object getObject(String str, Map map) throws SQLException {
        throw new SQLException("not supported");
    }

    public Object getObject(int i, Map map) throws SQLException {
        throw new SQLException("not supported");
    }

    public Ref getRef(int i) throws SQLException {
        throw new SQLException("not supported");
    }

    public Ref getRef(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public Blob getBlob(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public Blob getBlob(int i) throws SQLException {
        throw new SQLException("not supported");
    }

    public Clob getClob(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public Clob getClob(int i) throws SQLException {
        throw new SQLException("not supported");
    }

    public Array getArray(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    public Array getArray(int i) throws SQLException {
        throw new SQLException("not supported");
    }

    public Date getDate(String str, Calendar calendar) throws SQLException {
        throw new SQLException("not supported");
    }

    public Date getDate(int i, Calendar calendar) throws SQLException {
        throw new SQLException("not supported");
    }

    public Time getTime(String str, Calendar calendar) throws SQLException {
        throw new SQLException("not supported");
    }

    public Time getTime(int i, Calendar calendar) throws SQLException {
        throw new SQLException("not supported");
    }

    public Timestamp getTimestamp(String str, Calendar calendar) throws SQLException {
        throw new SQLException("not supported");
    }

    public Timestamp getTimestamp(int i, Calendar calendar) throws SQLException {
        throw new SQLException("not supported");
    }

    public URL getURL(String str) throws SQLException {
        throw new SQLException("not supported");
    }

    @Override // java.sql.PreparedStatement
    public void setRowId(int i, RowId rowId) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setRowId(String str, RowId rowId) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setNString(int i, String str) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setNString(String str, String str2) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setNCharacterStream(int i, Reader reader, long j) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setNCharacterStream(String str, Reader reader, long j) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setNClob(int i, NClob nClob) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setNClob(String str, NClob nClob) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setClob(int i, Reader reader, long j) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setClob(String str, Reader reader, long j) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setBlob(int i, InputStream inputStream, long j) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setBlob(String str, InputStream inputStream, long j) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setNClob(int i, Reader reader, long j) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setNClob(String str, Reader reader, long j) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setSQLXML(int i, SQLXML sqlxml) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setSQLXML(String str, SQLXML sqlxml) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setAsciiStream(int i, InputStream inputStream, long j) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setAsciiStream(String str, InputStream inputStream, long j) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setBinaryStream(int i, InputStream inputStream, long j) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setBinaryStream(String str, InputStream inputStream, long j) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setCharacterStream(int i, Reader reader, long j) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setCharacterStream(String str, Reader reader, long j) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setAsciiStream(int i, InputStream inputStream) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setAsciiStream(String str, InputStream inputStream) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setBinaryStream(int i, InputStream inputStream) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setBinaryStream(String str, InputStream inputStream) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setCharacterStream(int i, Reader reader) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setCharacterStream(String str, Reader reader) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setNCharacterStream(int i, Reader reader) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setNCharacterStream(String str, Reader reader) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setClob(int i, Reader reader) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setClob(String str, Reader reader) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setBlob(int i, InputStream inputStream) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setBlob(String str, InputStream inputStream) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override // java.sql.PreparedStatement
    public void setNClob(int i, Reader reader) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    public void setNClob(String str, Reader reader) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }
}
